// Copyright (c) 2018 The LevelDB Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file. See the AUTHORS file for names of contributors.

#ifndef STORAGE_LEVELDB_PORT_PORT_STDCXX_H_
#define STORAGE_LEVELDB_PORT_PORT_STDCXX_H_

// port/port_config.h availability is automatically detected via __has_include
// in newer compilers. If LEVELDB_HAS_PORT_CONFIG_H is defined, it overrides the
// configuration detection.
#if defined(LEVELDB_HAS_PORT_CONFIG_H)

#if LEVELDB_HAS_PORT_CONFIG_H
#include "port/port_config.h"
#endif  // LEVELDB_HAS_PORT_CONFIG_H

#elif defined(__has_include)

#if __has_include("port/port_config.h")

#include "port/port_config.h"

#endif  // __has_include("port/port_config.h")

#endif  // defined(LEVELDB_HAS_PORT_CONFIG_H)

#if HAVE_CRC32C
#include <crc32c/crc32c.h>
#endif  // HAVE_CRC32C
#if HAVE_SNAPPY
#include <snappy.h>
#endif  // HAVE_SNAPPY

#include <cassert>
#include <condition_variable>  // NOLINT
#include <cstddef>
#include <cstdint>
#include <mutex>  // NOLINT
#include <string>

#include "port/thread_annotations.h"

namespace leveldb {
    namespace port {

        class CondVar;

// Thinly wraps std::mutex.
        class LOCKABLE Mutex {
        public:
            Mutex() = default;

            ~Mutex() = default;

            Mutex(const Mutex &) = delete;

            Mutex &operator=(const Mutex &) = delete;

            void Lock() EXCLUSIVE_LOCK_FUNCTION() { mu_.lock(); }

            void Unlock() UNLOCK_FUNCTION() { mu_.unlock(); }

            void AssertHeld() ASSERT_EXCLUSIVE_LOCK() {}

        private:
            friend class CondVar;

            std::mutex mu_;
        };

// Thinly wraps std::condition_variable.
        class CondVar {
        public:
            explicit CondVar(Mutex *mu) : mu_(mu) { assert(mu != nullptr); }

            ~CondVar() = default;

            CondVar(const CondVar &) = delete;

            CondVar &operator=(const CondVar &) = delete;

            void Wait() {
                std::unique_lock<std::mutex> lock(mu_->mu_, std::adopt_lock);
                cv_.wait(lock);
                lock.release();
            }

            void Signal() { cv_.notify_one(); }

            void SignalAll() { cv_.notify_all(); }

        private:
            std::condition_variable cv_;
            Mutex *const mu_;
        };

        inline bool Snappy_Compress(const char *input, size_t length,
                                    std::string *output) {
#if HAVE_SNAPPY
            output->resize(snappy::MaxCompressedLength(length));
            size_t outlen;
            snappy::RawCompress(input, length, &(*output)[0], &outlen);
            output->resize(outlen);
            return true;
#else
            // Silence compiler warnings about unused arguments.
            (void) input;
            (void) length;
            (void) output;
#endif  // HAVE_SNAPPY

            return false;
        }

        inline bool Snappy_GetUncompressedLength(const char *input, size_t length,
                                                 size_t *result) {
#if HAVE_SNAPPY
            return snappy::GetUncompressedLength(input, length, result);
#else
            // Silence compiler warnings about unused arguments.
            (void) input;
            (void) length;
            (void) result;
            return false;
#endif  // HAVE_SNAPPY
        }

        inline bool Snappy_Uncompress(const char *input, size_t length, char *output) {
#if HAVE_SNAPPY
            return snappy::RawUncompress(input, length, output);
#else
            // Silence compiler warnings about unused arguments.
            (void) input;
            (void) length;
            (void) output;
            return false;
#endif  // HAVE_SNAPPY
        }

        inline bool GetHeapProfile(void (*func)(void *, const char *, int), void *arg) {
            // Silence compiler warnings about unused arguments.
            (void) func;
            (void) arg;
            return false;
        }

        inline uint32_t AcceleratedCRC32C(uint32_t crc, const char *buf, size_t size) {
#if HAVE_CRC32C
            return ::crc32c::Extend(crc, reinterpret_cast<const uint8_t*>(buf), size);
#else
            // Silence compiler warnings about unused arguments.
            (void) crc;
            (void) buf;
            (void) size;
            return 0;
#endif  // HAVE_CRC32C
        }

    }  // namespace port
}  // namespace leveldb

#endif  // STORAGE_LEVELDB_PORT_PORT_STDCXX_H_
